home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 49 / Amiga Format CD49 (2000-01-17)(Future Publishing)(GB)(Track 1 of 3)[!][issue 2000-02].iso / -serious- / programming / mui / mcc_popph / mcc_popph_src / popphs.c < prev    next >
C/C++ Source or Header  |  1999-11-30  |  12KB  |  499 lines
  1.  
  2. /*
  3. ** $Id: popphs.c,v 1.3 1999/11/16 20:58:12 carlos Exp $
  4. **
  5. ** © 1999 Marcin Orlowski <carlos@amiga.com.pl>
  6. */
  7.  
  8. #include "popph.h"
  9.  
  10. #define __NAME "Popphs"
  11.  
  12. /*
  13. #define MSG_MENU_TITLE   "Menu"
  14. #define MSG_MENU_CUT     "Cut"
  15. #define MSG_MENU_COPY    "Copy"
  16. #define MSG_MENU_PASTE   "Paste"
  17. #define MSG_MENU_CLEAR   "Clear"
  18. */
  19.  
  20. /// _DoCopy
  21. int _DoCopy( Object *obj, struct PPHS_Data *data  )
  22. {
  23. char *buf = (char *)xget( obj, data->tag_contents );
  24. int  len = strlen( buf );
  25.  
  26.     return( _WriteClip( buf, len, data->clip_device ) );
  27. }
  28. //|
  29. /// _DoCut
  30. int _DoCut( Object *obj, struct PPHS_Data *data )
  31. {
  32.  
  33. int  result = _DoCopy( obj, data );
  34.  
  35.     if( result )
  36.        set( obj, data->tag_contents, "" );
  37.  
  38.     return( result );
  39. }
  40. //|
  41.  
  42. /// DoCopy
  43. ULONG PPHS_DoCopy( struct IClass *cl, Object *obj, struct opSet *msg )
  44. {
  45. struct PPHS_Data *data = INST_DATA(cl,obj);
  46.  
  47.  
  48.     switch( data->stringtype )
  49.        {
  50.        case MUIV_Popph_StringType_Betterstring:
  51.             {
  52.             char *buf = (char *)(xget( obj, data->tag_contents ) + xget( obj, data->tag_bufpos ));
  53.             int  len = xget( obj, MUIA_BetterString_SelectSize );
  54.  
  55.             // we do cut marked area only if there's any...
  56.             if( len != 0 )
  57.                {
  58.                // we need to do some calculations for reverse mark
  59.                if( len < 0 )
  60.                    {
  61.                    buf -= abs(len);
  62.                    }
  63.  
  64.                _WriteClip( buf, abs(len), data->clip_device );
  65.                }
  66.             else
  67.                {
  68.                _DoCopy( obj, data );
  69.                }
  70.             }
  71.             break;
  72.  
  73.  
  74.        case MUIV_Popph_StringType_Textinput:
  75.             {
  76.             DoMethod( obj, MUIM_Textinput_DoCopy );
  77.             }
  78.             break;
  79.  
  80.  
  81. //       case MUIV_Popph_StringType_String:
  82.        default:
  83.             {
  84.             char *buf = (char *)xget( obj, data->tag_contents );
  85.             int  len = strlen( buf );
  86.  
  87.             _WriteClip( buf, len, data->clip_device );
  88.             }
  89.             break;
  90.        }
  91.  
  92.     return( 0 );
  93. }
  94. //|
  95. /// DoCut
  96. ULONG PPHS_DoCut( struct IClass *cl, Object *obj, struct opSet *msg )
  97. {
  98. struct PPHS_Data *data = INST_DATA(cl,obj);
  99.  
  100.  
  101.     DoMethod( obj, MUIM_Popph_DoCopy );
  102.  
  103.  
  104.     switch( data->stringtype )
  105.        {
  106.        case MUIV_Popph_StringType_Textinput:
  107.             {
  108.             }
  109.             break;
  110.  
  111.        case MUIV_Popph_StringType_Betterstring:
  112.             {
  113.             if( xget( obj, MUIA_BetterString_SelectSize ) == 0 )
  114.                set( obj, data->tag_contents, "" );
  115.             else
  116.                DoMethod( obj, MUIM_BetterString_ClearSelected );
  117.             }
  118.             break;
  119.  
  120. //       case MUIV_Popph_StringType_String:
  121.        default:
  122.             {
  123.             set( obj, data->tag_contents, "" );
  124.             }
  125.             break;
  126.  
  127.        }
  128.  
  129.     return( 0 );
  130. }
  131. //|
  132.  
  133. /*
  134. /// ContextMenu
  135. static struct NewMenu pphs_menu[] =
  136. {
  137.     { NM_TITLE, (STRPTR)MSG_MENU_TITLE    ,0,0,0, (APTR)0  },
  138.  
  139. //        { NM_ITEM, (STRPTR)NM_BARLABEL                  ,0,0,0,(APTR)0  },
  140.  
  141.     { NM_ITEM,   (STRPTR)MSG_MENU_CUT     ,0,0,0, (APTR)MUIM_Popph_DoCut   },
  142.     { NM_ITEM,   (STRPTR)MSG_MENU_COPY    ,0,0,0, (APTR)MUIM_Popph_DoCopy  },
  143. //    { NM_ITEM,   (STRPTR)MSG_MENU_PASTE   ,0,0,0, (APTR)MUIM_Popph_DoPaste },
  144.     { NM_ITEM,   (STRPTR)MSG_MENU_CLEAR   ,0,0,0, (APTR)MUIM_Popph_DoClear },
  145.  
  146.     { NM_END,NULL,0,0,0,(APTR)0 }
  147. };
  148. //|
  149. */
  150.  
  151. /// OM_NEW
  152.  
  153. ULONG ASM PPHS_New(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) struct opSet *msg)
  154. {
  155.  
  156. struct PPHS_Data *data;
  157.  
  158. ULONG tag_contents;
  159. ULONG tag_bufpos;
  160. ULONG tag_maxlen;
  161. ULONG strmaxlen;
  162.  
  163.  
  164.     strmaxlen = GetTagData( MUIA_Popph_StringMaxLen, 0, ((struct opSet *)msg)->ops_AttrList );
  165.  
  166.  
  167.     switch( GetTagData( MUIA_Popph_StringType, MUIV_Popph_StringType_String,  ((struct opSet *)msg)->ops_AttrList ))
  168.            {
  169.            // MUIC_BetterString
  170.            // MUIC_String
  171.            case MUIV_Popph_StringType_String:
  172.            case MUIV_Popph_StringType_Betterstring:
  173.                tag_contents = MUIA_String_Contents;
  174.                tag_bufpos   = MUIA_String_BufferPos;
  175.                tag_maxlen   = MUIA_String_MaxLen;
  176.                break;
  177.  
  178.            // MUIC_Textinput
  179.            case MUIV_Popph_StringType_Textinput:
  180.                tag_contents = MUIA_Textinput_Contents;
  181.                tag_bufpos   = MUIA_Textinput_CursorPos;
  182.                tag_maxlen   = MUIA_Textinput_MaxLen;
  183.                break;
  184.            }
  185.  
  186.  
  187.     obj = (Object *)DoSuperNew(cl,obj,
  188.                 MUIA_Textinput_DefaultPopup, FALSE,
  189.                 tag_maxlen, strmaxlen,
  190. //                MUIA_ContextMenu, TRUE,
  191.                 TAG_MORE, msg->ops_AttrList);
  192.  
  193.     if( obj )
  194.         {
  195.         // init data
  196.  
  197.         data = INST_DATA(cl, obj);
  198.  
  199.  
  200.         // some defaults
  201.  
  202.         data->dropobj     = NULL;
  203.         data->separator   = '|';
  204.         data->replacemode = FALSE;
  205.  
  206.         data->stringtype  = GetTagData( MUIA_Popph_StringType, MUIV_Popph_StringType_String, ((struct opSet *)msg)->ops_AttrList );
  207.  
  208.         data->contextmenu   = NULL;
  209.         data->cmenu_enabled = TRUE;
  210.  
  211.         data->tag_contents = tag_contents;
  212.         data->tag_bufpos   = tag_bufpos;
  213.         data->tag_maxlen   = tag_maxlen;
  214.  
  215.         data->clip_device  = 0;        // default clipboard device
  216.  
  217.  
  218.         // trick to set arguments
  219.         msg->MethodID = OM_SET;
  220.         DoMethodA(obj, (Msg)msg);
  221.         msg->MethodID = OM_NEW;
  222.         }
  223.  
  224.     return((ULONG)obj);
  225. }
  226. //|
  227. /// OM_DISPOSE
  228. ULONG PPHS_Dispose(struct IClass *cl, Object *obj, struct opSet *msg)
  229. {
  230. struct PPHS_Data *data = INST_DATA(cl,obj);
  231.  
  232.  
  233.     D(bug(__NAME ": OM_DISPOSE\n"));
  234.  
  235.     if( data->contextmenu )
  236.        MUI_DisposeObject( data->contextmenu );
  237.  
  238.     return( DoSuperMethodA(cl, obj, msg) );
  239. }
  240. //|
  241. /// OM_SET
  242.  
  243. ULONG ASM PPHS_Set(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  244. {
  245. struct PPHS_Data *data = INST_DATA(cl,obj);
  246. struct TagItem *tags, *tag;
  247.  
  248.  
  249.     for(tags=((struct opSet *)msg)->ops_AttrList; tag=NextTagItem(&tags); )
  250.        {
  251. //       D(bug(__NAME ": OM_SET Tag: %lx\n", tag->ti_Tag));
  252.  
  253.        switch(tag->ti_Tag)
  254.           {
  255.           case MUIA_Popph_Contents:
  256.                set( obj, data->tag_contents, tag->ti_Data );
  257.                break;
  258.  
  259.           case MUIA_Popph_BufferPos:
  260.                set( obj, data->tag_bufpos, tag->ti_Data );
  261.                break;
  262.  
  263.           case MUIA_Popph_StringKey:
  264.                set( obj, MUIA_ControlChar, tag->ti_Data );
  265.                break;
  266.  
  267.           case MUIA_Popph_Separator:
  268.                data->separator = tag->ti_Data;
  269.                break;
  270.  
  271.           case MUIA_Popph_DropObject:
  272.                data->dropobj = (Object *)tag->ti_Data;
  273.                break;
  274.  
  275.           case MUIA_Popph_ReplaceMode:
  276.                data->replacemode = tag->ti_Data;
  277.                break;
  278.  
  279.           case MUIA_Popph_ContextMenu:
  280.                data->cmenu_enabled = tag->ti_Data;
  281.                set(obj, MUIA_ContextMenu, data->cmenu_enabled);
  282.                break;
  283.           }
  284.         }
  285.  
  286.     return(DoSuperMethodA(cl, obj, msg));
  287. }
  288.  
  289. //|
  290. /// OM_GET
  291. static ULONG ASM PPHS_Get(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  292. {
  293. struct PPHS_Data *data = INST_DATA(cl,obj);
  294. ULONG  *store = ((struct opGet *)msg)->opg_Storage;
  295.  
  296. //    D(bug( __NAME ": OM_GET\n"));
  297.  
  298.     switch(((struct opGet *)msg)->opg_AttrID)
  299.        {
  300.        case MUIA_Popph_Contents:
  301.             *store = xget( obj, data->tag_contents );
  302.             return(TRUE);
  303.  
  304.        case MUIA_Popph_BufferPos:
  305.             *store = xget( obj, data->tag_bufpos );
  306.             return(TRUE);
  307.  
  308.        case MUIA_Popph_Separator:
  309.             *store = data->separator;
  310.             return(TRUE);
  311.  
  312.        case MUIA_Popph_StringMaxLen:
  313.             *store = xget( obj, data->tag_maxlen );
  314.             return(TRUE);
  315.  
  316.        case MUIA_Popph_StringType:
  317.             *store = data->stringtype;
  318.             return(TRUE);
  319.  
  320.        case MUIA_Popph_ContextMenu:
  321.             *store = data->cmenu_enabled;
  322.             return(TRUE);
  323.  
  324.        }
  325.  
  326.     return(DoSuperMethodA(cl, obj, msg));
  327. }
  328. //|
  329.  
  330. /*
  331. /// ContextMenuBuild
  332.  
  333. ULONG PPHS_CMBuild(struct IClass *cl,Object *obj, struct MUIP_ContextMenuChoice *msg)
  334. {
  335. struct PPHS_Data *data = INST_DATA(cl,obj);
  336.  
  337.  
  338.     D(bug(__NAME ": CMBuild: Old: %lx\n", data->contextmenu));
  339.  
  340.     if( data->contextmenu )
  341.        MUI_DisposeObject( data->contextmenu );
  342.  
  343.  
  344.     if( (data->contextmenu = MUI_MakeObject( MUIO_MenustripNM, pphs_menu, 0 )) )
  345.            {
  346. //           set( obj, MUIA_ContextMenu, data->contextmenu );
  347.  
  348.            D(bug( __NAME ": ContextMenu: %lx\n", data->contextmenu ));
  349.            }
  350.  
  351.     return( (ULONG)data->contextmenu );
  352. }
  353.  
  354. //|
  355. /// ContextMenuChoice
  356.  
  357. ULONG PPHS_CMChoice(struct IClass *cl,Object *obj, struct MUIP_ContextMenuChoice *msg)
  358. {
  359. //struct PPHS_Data *data = INST_DATA(cl,obj);
  360.  
  361. LONG i = muiUserData( msg->item );
  362.  
  363.     D(bug( __NAME ": CMChoice: item: %lx\n", i ));
  364.  
  365.     if( i )
  366.        {
  367.        DoMethod( obj, i );
  368.        }
  369.  
  370.     return( 0 );
  371.  
  372. }
  373. //|
  374. */
  375.  
  376. /// mDragQuery
  377. ULONG PPHS_DragQuery(struct IClass *cl,Object *obj,struct MUIP_DragDrop *msg)
  378. {
  379. struct PPHS_Data *data = INST_DATA(cl,obj);
  380.  
  381.  
  382.     /* refuse to drop on ourselves */
  383.  
  384.     if( msg->obj != data->dropobj )
  385.        return(MUIV_DragQuery_Refuse);
  386.  
  387.     return(MUIV_DragQuery_Accept);
  388.  
  389. }
  390. //|
  391. /// mDragDrop
  392. ULONG PPHS_DragDrop(struct IClass *cl,Object *obj,struct MUIP_DragDrop *msg)
  393. {
  394. struct PPHS_Data *data = INST_DATA(cl,obj);
  395.  
  396. char *list_entry;
  397. char *current_string;
  398. char *buffer;
  399. char key[ POPPH_MAX_KEY_LEN ];
  400.  
  401.  
  402.     DoMethod(msg->obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &list_entry);
  403.  
  404.     if( list_entry )
  405.        {
  406.        int stringlen;
  407.        int keylen;
  408.        int pos;
  409.        char *zero;
  410.  
  411.  
  412.        zero = _strchr( list_entry, data->separator );
  413.  
  414.        if( zero )
  415.           keylen = _strlen( list_entry, data->separator );
  416.        else
  417.           keylen = _strlen( list_entry, '\0' );
  418.  
  419.  
  420.        CopyMem( list_entry, key, keylen );
  421.        key[ keylen ] = 0;
  422.  
  423.        if( data->replacemode )
  424.          {
  425.          set( obj, MUIA_Popph_Contents, key );
  426.          }
  427.        else
  428.          {
  429.          get( obj, MUIA_Popph_BufferPos, &pos );
  430.          get( obj, MUIA_Popph_Contents, ¤t_string );
  431.          stringlen = _strlen( current_string, 0 );
  432.  
  433.          if( buffer = AllocVec( keylen + stringlen + 5, MEMF_CLEAR ) )
  434.             {
  435.             CopyMem( current_string, buffer, pos );
  436.             CopyMem( key, buffer + pos, keylen );
  437.             CopyMem( current_string + pos, buffer + pos + keylen, stringlen - pos );
  438.  
  439.             set( obj, MUIA_Popph_Contents, buffer );
  440.             set( obj, MUIA_Popph_BufferPos, pos + keylen );
  441. //           set( xget( obj, MUIA_Window ), MUIA_Window_ActiveObject, obj );
  442.  
  443. //           DoMethod(_app(obj), MUIM_Application_PushMethod,
  444. //           _win(obj), 3, MUIM_Set, MUIA_Window_ActiveObject, obj);
  445.  
  446.             FreeVec( buffer );
  447.             }
  448.          }
  449.        }
  450.  
  451.        return( 0 );
  452.  
  453. }
  454. //|
  455.  
  456. /// Dispatcher
  457. ULONG ASM SAVEDS PPHS_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  458. {
  459. //struct PPHS_Data *data = INST_DATA(cl,obj);
  460.  
  461. //    D(bug(__NAME ": Disp: %lx\n", msg->MethodID ));
  462.  
  463.     switch( msg->MethodID )
  464.        {
  465.        case OM_NEW    : return(PPHS_New     (cl, obj, (APTR)msg));
  466.        case OM_DISPOSE: return(PPHS_Dispose (cl, obj, (APTR)msg));
  467.        case OM_SET    : return(PPHS_Set     (cl, obj, (APTR)msg));
  468.        case OM_GET    : return(PPHS_Get     (cl, obj, (APTR)msg));
  469. /*
  470.        case MUIM_ContextMenuBuild  : return(PPHS_CMBuild   (cl, obj, (APTR)msg));
  471.        case MUIM_ContextMenuChoice : return(PPHS_CMChoice  (cl, obj, (APTR)msg));
  472. */
  473.  
  474.        case MUIM_Popph_DoCut   :  return(PPHS_DoCut (cl, obj, (APTR)msg));
  475.        case MUIM_Popph_DoCopy  :  return(PPHS_DoCut (cl, obj, (APTR)msg));
  476.  
  477.  
  478. //#define MUIM_Textinput_DoPaste MCC_TI_ID(14)            /* V1 */
  479.  
  480. //       case MUIM_Popph_DoPaste:
  481. /*
  482.        case MUIM_Popph_DoClear:
  483.             {
  484.             set( obj, data->tag_contents, "" );
  485.             }
  486.             return(0);
  487. */
  488.        case MUIM_DragQuery: return(PPHS_DragQuery (cl, obj, (APTR)msg));
  489.        case MUIM_DragDrop : return(PPHS_DragDrop  (cl, obj, (APTR)msg));
  490.        }
  491.  
  492.     return((ULONG)DoSuperMethodA(cl,obj,msg));
  493.  
  494. }
  495. //|
  496.  
  497. #undef __NAME
  498.  
  499.